home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 10 / AACD 10.iso / AACD / Games / MAME / src / machine / cchasm.c < prev    next >
C/C++ Source or Header  |  2000-04-23  |  5KB  |  230 lines
  1. #include "driver.h"
  2. #include "vidhrdw/vector.h"
  3. #include "machine/z80fmly.h"
  4.  
  5. #define M6840_CYCLE 1250  /* 800 kHz */
  6.  
  7. static int m6840_cr_select=2;
  8. static int m6840_timerLSB[3];
  9. static int m6840_timerMSB[3];
  10. static int m6840_status;
  11. static int m6840_cr[3];
  12.  
  13.  
  14. static void cchasm_6840_irq (int state)
  15. {
  16.     cpu_set_irq_line (0, 4, state);
  17. }
  18.  
  19. static void timer_2_timeout (int dummy)
  20. {
  21.  
  22.     if (m6840_cr[1] & 0x40)
  23.     {
  24.         /* set interrupt flags */
  25.         m6840_status |= 0x82;
  26.         cchasm_6840_irq(ASSERT_LINE);
  27.     }
  28. }
  29.  
  30. /* from machine/mcr68.c modified for Cosmic Chasm (still very incomplete) */
  31.  
  32. READ_HANDLER( cchasm_6840_r )
  33. {
  34.     /* From datasheet:
  35.         0 - nothing
  36. 2        1 - read status register
  37. 4        2 - read timer 1 counter
  38. 6        3 - read lsb buffer
  39. 8        4 - timer 2 counter
  40. a        5 - read lsb buffer
  41. c        6 - timer 3 counter
  42. e        7 - lsb buffer
  43.  
  44.  
  45.     */
  46.  
  47.     switch (offset) {
  48.         case 0x0:
  49.             logerror("Read from unimplemented port...\n");
  50.             break;
  51.  
  52.         case 0x2:
  53.             logerror("Read status register\n");
  54.  
  55.             return m6840_status;
  56.             break;
  57.  
  58.         case 0x4:
  59.             logerror("Read MSB of timer 1 (%d)\n",m6840_timerMSB[0]);
  60.             return m6840_timerMSB[0];
  61.  
  62.         case 0x6:
  63.             logerror("Read LSB of timer 1\n");
  64.             return m6840_timerLSB[0];
  65.  
  66.         case 0x8:
  67.             logerror("Read MSB of timer 2 %i\n",m6840_timerMSB[1]);
  68.             return m6840_timerMSB[1];
  69.  
  70.         case 0xa:
  71.             logerror("Read LSB of timer 2 %i\n",m6840_timerLSB[1]);
  72.             return m6840_timerLSB[1];
  73.  
  74.         case 0xc:
  75.             logerror("Read MSB of timer 3 (%d)\n",m6840_timerMSB[2]);
  76.             return m6840_timerMSB[2];
  77.  
  78.         case 0xe:
  79.             logerror("Read LSB of timer 3\n");
  80.             return m6840_timerLSB[2];
  81.     }
  82.  
  83.     return 0;
  84. }
  85.  
  86.  
  87. WRITE_HANDLER( cchasm_6840_w )
  88. {
  89.  
  90.     /* From datasheet:
  91.  
  92.  
  93. 0        0 - write control reg 1/3 (reg 1 if lsb of Reg 2 is 1, else 3)
  94. 2        1 - write control reg 2
  95. 4        2 - write msb buffer reg
  96. 6        3 - write timer 1 latch
  97. 8        4 - msb buffer register
  98. a        5 - write timer 2 latch
  99. c        6 - msb buffer reg
  100. e        7 - write timer 3 latch
  101.  
  102.  
  103. So:
  104.  
  105. Write ff0100 to 6840 02  = }
  106. Write ff0000 to 6840 00  = } Write 0 to control reg 1
  107.  
  108. Write ff0000 to 6840 02
  109.  
  110. Write ff0000 to 6840 0c
  111. Write ff3500 to 6840 0e  = } Write 0035 to timer 3 latch?
  112.  
  113. Write ff0a00 to 6840 00  = } Write 0a to control reg 3
  114.  
  115.     */
  116.  
  117.     data &= 0xff;
  118.  
  119.  
  120.     switch (offset) {
  121.         case 0x0: /* CR1/3 */
  122.             m6840_cr[m6840_cr_select] = data;
  123.  
  124.             if (m6840_cr_select==0)
  125.             {
  126.                 if ((data&0x1))
  127.                 {
  128.                     int i;
  129.                     logerror("MC6840: Internal reset\n");
  130.                     for (i=0; i<3; i++) {
  131.                         m6840_timerLSB[i]=255;
  132.                         m6840_timerMSB[i]=255;
  133.  
  134.                     }
  135.                 }
  136.                 else
  137.                     logerror("MC6840: Timers go!\n");
  138.  
  139.  
  140.             }
  141.  
  142.             else if (m6840_cr_select==2) {
  143.                 if (data&0x1)
  144.                     logerror("MC6840: Divide by 8 prescaler selected\n");
  145.             }
  146.  
  147.             /* Following bits apply to both registers */
  148.             if (data&0x2)
  149.                 logerror("MC6840: Internal clock selected on CR %d\n",m6840_cr_select);
  150.             else
  151.                 logerror("MC6840: External clock selected on CR %d\n",m6840_cr_select);
  152.  
  153.             if (data&0x4)
  154.                 logerror("MC6840: Dual 8 bit count mode selected on CR %d\n",m6840_cr_select);
  155.             else
  156.                 logerror("MC6840: 16 bit count mode selected on CR %d\n",m6840_cr_select);
  157.  
  158.             logerror(" Write %02x to control register 1/3\n",data);
  159.             break;
  160.         case 0x2:
  161.             m6840_cr[1] = data;
  162.             if (data&0x1)
  163.             {
  164.                 m6840_cr_select=0;
  165.                 logerror("MC6840: Control register 1 selected\n");
  166.             }
  167.             else {
  168.                 m6840_cr_select=2;
  169.                 logerror("MC6840: Control register 3 selected\n");
  170.             }
  171.  
  172.             if (data&0x80)
  173.                 logerror("MC6840: Cr2 Timer output enabled\n");
  174.  
  175.             if (data&0x40)
  176.                 logerror("MC6840: Cr2 interrupt output enabled\n");
  177.  
  178.             logerror(" Write %02x to control register 2\n",data);
  179.             break;
  180.         case 0x4:
  181.             m6840_timerMSB[0]=data;
  182.             m6840_status &= ~0x01;
  183.             logerror(" Write %02x to MSB of Timer 1\n",data);
  184.             break;
  185.         case 0x6:
  186.             m6840_status &= ~0x01;
  187.             m6840_timerLSB[0]=data;
  188.             logerror(" Write %02x to LSB of Timer 1\n",data);
  189.             break;
  190.         case 0x8:
  191.             m6840_status &= ~0x02;
  192.             cchasm_6840_irq(CLEAR_LINE);
  193.             m6840_timerMSB[1]=data;
  194.             if ((m6840_cr[1] & 0x38) == 0)
  195.                 timer_set (TIME_IN_NSEC(M6840_CYCLE) * ((m6840_timerMSB[1]<<8) | m6840_timerLSB[1]), 0, timer_2_timeout);
  196.             logerror(" Write %02x to MSB of Timer 2\n",data);
  197.             break;
  198.         case 0xa:
  199.             m6840_status &= ~0x02;
  200.             cchasm_6840_irq(CLEAR_LINE);
  201.             m6840_timerLSB[1]=data;
  202.             logerror(" Write %02x to LSB of Timer 2\n",data);
  203.             break;
  204.         case 0xc:
  205.             m6840_status &= ~0x04;
  206.             m6840_timerMSB[2]=data;
  207.             logerror(" Write %02x to MSB of Timer 3\n",data);
  208.             break;
  209.         case 0xe:
  210.             m6840_status &= ~0x04;
  211.             m6840_timerLSB[2]=data;
  212.             logerror(" Write %02x to LSB of Timer 3\n",data);
  213.             break;
  214.     }
  215.  
  216. /*    logerror("Write %04x to 6840 %02x\n",data,offset); */
  217.  
  218. }
  219.  
  220. WRITE_HANDLER( cchasm_led_w )
  221. {
  222.     /*logerror("LED write %x to %x\n", data, offset);*/
  223. }
  224.  
  225. WRITE_HANDLER( cchasm_watchdog_w )
  226. {
  227.     /*logerror("watchdog write %x to %x\n", data, offset);*/
  228. }
  229.  
  230.